using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections;
using Microsoft.ApplicationBlocks.Data;
using Common;
//using MinCultura.Sinic.SystemFrameworks;
using DataAccess;
using SystemFrameworks;

namespace BusinessRules
{
    public class FlujosEstadosPermisos : SINIC
    {
        #region Constantes
        private const String FEP_ID_PARAM = "@FEP_ID";
        private const String PER_ID_PARAM = "@PER_ID";
        private const String OPC_ID_PARAM = "@OPC_ID";
        private const String ACC_ID_PARAM = "@ACC_ID";
        private const String FLE_ESTADO_INICIAL_PARAM = "@FLE_ESTADO_INICIAL";
        private const String FLE_ESTADO_FINAL_PARAM = "@FLE_ESTADO_FINAL";
        private const String FLE_EXIGE_VIGENCIA_PARAM = "@FLE_EXIGE_VIGENCIA";
        private const String FLE_EXIGE_INFO_ADICIONAL_PARAM = "@FLE_EXIGE_INFO_ADICIONAL";
        private const String FLU_ID_PARAM = "@FLU_ID";
        #endregion Constantes


        #region Constructor
        public FlujosEstadosPermisos()
        {
        }
        #endregion Constructor

        #region Metodos

        #region Publicos

        #region ValidarPlantilla
        /// <summary>
        /// 
        /// </summary>
        /// <param name="idflujoplantilla"></param>
        /// <param name="idOpcion"></param>
        /// <param name="idPerfil"></param>
        /// <param name="mensaje"></param>
        /// <returns></returns>
        public bool ValidarPlantilla(short idflujoplantilla, decimal idOpcion, decimal idPerfil, ref string mensaje)
        {
            bool response = true;
            try
            {
                DataTable dtAccionesFlujo = new DataTable("ACCIONES_FLUJO");
                DataTable dtAccionesOpcion = new DataTable("ACCIONES_OPCION");


                SqlParameter param1 = new SqlParameter(FLU_ID_PARAM, idflujoplantilla);
                SqlParameter param2 = new SqlParameter(PER_ID_PARAM, idPerfil);
                SqlParameter param3 = new SqlParameter(OPC_ID_PARAM, idOpcion);
                SqlParameter[] parameters1 = { param1 };
                SqlParameter[] parameters2 = { param2, param3 };
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ACCIONES_ADM_FLUJO_ESTADO", dtAccionesFlujo, parameters1);
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ADM_PERMISOS_ACCIONES", dtAccionesOpcion, parameters2);
                bool control = true;
                if (dtAccionesFlujo.Rows.Count > 0)
                {
                    foreach (DataRow draccionesFlujo in dtAccionesFlujo.Rows)
                    {
                        decimal accionflujo = Convert.ToDecimal(draccionesFlujo[FlujosEstadosPermisosData.ACC_ID_FIELD]);

                        if (dtAccionesOpcion.Rows.Count > 0)
                        {
                            foreach (DataRow draccionesopcion in dtAccionesOpcion.Rows)
                            {
                                decimal accionopcion = Convert.ToDecimal(draccionesopcion[FlujosEstadosPermisosData.ACC_ID_FIELD]);
                                if (accionflujo != accionopcion)
                                {
                                    control = false;
                                }
                                else
                                {
                                    control = true;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            control = false;
                            break;
                        }
                    }
                }
                else
                {
                    mensaje = "El flujo no posee estados configurados comuniquese con el administrador del sistema";
                }
                if (!control)
                {
                    mensaje = "El flujo no puede ser asignado ya que la opcion no tiene permisos sobre todas las acciones que posee el flujo";
                }
                if (mensaje.Length > 0)
                {
                    response = false;
                }
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "Flujos Estados Permisos"), sqlEx);
            }
            catch (Exception e)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorConsultar", "Flujos Estados Permisos"), e);
            }
            return response;
        }
        #endregion ValidarPlantilla

        #region BuscarFlujosEstadosPermisos
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public FlujosEstadosPermisosData BuscarFlujosEstadosPermisos()
        {
            FlujosEstadosPermisosData response = new FlujosEstadosPermisosData();
            SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_BUSCAR_ADM_FLUJO_ESTADO_PERMISO", response);
            return response;
        }
        #endregion BuscarFlujosEstadosPermisos

        #region ConsultarFlujosEstadoPermisos
        /// <summary>
        /// 
        /// </summary>
        /// <param name="intIdFlujoEstadoPermiso"></param>
        /// <returns></returns>
        public FlujosEstadosPermisosData ConsultarFlujosEstadoPermisos(int intIdFlujoEstadoPermiso)
        {
            FlujosEstadosPermisosData response = new FlujosEstadosPermisosData();
            SqlParameter param1 = new SqlParameter(FEP_ID_PARAM, intIdFlujoEstadoPermiso);

            SqlParameter[] parameters = { param1 };
            try
            {
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO", response, parameters);
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO"), sqlEx);
            }
            catch (Exception ex)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorConsultar", GetType().FullName), ex);
            }
            return response;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="decIdPerfil"></param>
        /// <param name="decIdOpcion"></param>
        /// <returns></returns>
        public FlujosEstadosPermisosData ConsultarFlujosEstadoPermisos(decimal decIdPerfil, decimal decIdOpcion)
        {
            FlujosEstadosPermisosData response = new FlujosEstadosPermisosData();
            SqlParameter param1 = new SqlParameter(PER_ID_PARAM, decIdPerfil);
            SqlParameter param2 = new SqlParameter(OPC_ID_PARAM, decIdOpcion);
            SqlParameter[] parameters = { param1, param2 };
            try
            {
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO_POR_PERMISO", response, parameters);
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO_POR_PERMISO"), sqlEx);
            }
            catch (Exception ex)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorConsultar", GetType().FullName), ex);
            }
            return response;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="decIdPerfil"></param>
        /// <param name="decIdOpcion"></param>
        /// <returns></returns>
        public bool ConsultarFlujoEstadoPerfilOpcion(decimal decIdPerfil, decimal decIdOpcion)
        {
            bool retorno = true;
            FlujosEstadosPermisosData response = new FlujosEstadosPermisosData();
            SqlParameter param1 = new SqlParameter(PER_ID_PARAM, decIdPerfil);
            SqlParameter param2 = new SqlParameter(OPC_ID_PARAM, decIdOpcion);
            SqlParameter[] parameters = { param1, param2 };
            try
            {
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO_POR_PERMISO", response, parameters);
                if (!(response.Rows.Count > 0))
                {
                    retorno = false;
                }
                response.Dispose();
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO_POR_PERMISO"), sqlEx);
            }
            catch (Exception ex)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorConsultar", GetType().FullName), ex);
            }
            return retorno;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="decIdPerfil"></param>
        /// <param name="decIdOpcion"></param>
        /// <param name="decIdAccion"></param>
        /// <returns></returns>
        public FlujosEstadosPermisosData ConsultarFlujosEstadoPermisos(decimal decIdPerfil, decimal decIdOpcion, decimal decIdAccion)
        {
            FlujosEstadosPermisosData response = new FlujosEstadosPermisosData();
            SqlParameter param1 = new SqlParameter(PER_ID_PARAM, decIdPerfil);
            SqlParameter param2 = new SqlParameter(OPC_ID_PARAM, decIdOpcion);
            SqlParameter param3 = new SqlParameter(ACC_ID_PARAM, decIdAccion);
            SqlParameter[] parameters = { param1, param2, param3 };
            try
            {
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO_POR_ACC_OPC_PER", response, parameters);
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_CONSULTAR_ADM_FLUJO_ESTADO_PERMISO_POR_ACC_OPC_PER"), sqlEx);
            }
            catch (Exception ex)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorConsultar", GetType().FullName), ex);
            }
            return response;
        }
        #endregion ConsultarFlujosEstadoPermisos

        #region ConsultarAccionesOpcionPerfil
        /// <summary>
        /// 
        /// </summary>
        /// <param name="IdPerfil"></param>
        /// <param name="IdOpcion"></param>
        /// <returns></returns>
        public ArrayList ConsultarAccionesOpcionPerfil(decimal IdPerfil, decimal IdOpcion)
        {
            ArrayList response = new ArrayList();
            try
            {
                DataTable dtAccionesOpcion = new DataTable();
                SqlParameter param1 = new SqlParameter(PER_ID_PARAM, IdPerfil);
                SqlParameter param2 = new SqlParameter(OPC_ID_PARAM, IdOpcion);
                SqlParameter[] parameters = { param1, param2 };
                SqlHelper.ExecuteDataTable(this.ConnectionString, CommandType.StoredProcedure, "PAS_CONSULTAR_ADM_PERMISOS_ACCIONES", dtAccionesOpcion, parameters);

                if (dtAccionesOpcion.Rows.Count > 0)
                {
                    foreach (DataRow row in dtAccionesOpcion.Rows)
                    {
                        response.Add(Convert.ToDecimal(row[FlujosEstadosPermisosData.ACC_ID_FIELD]));
                    }
                }
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_CONSULTAR_ADM_PERMISOS_ACCIONES"), sqlEx);
            }
            catch (Exception ex)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorConsultar", GetType().FullName), ex);
            }
            return response;
        }
        #endregion ConsultarAccionesOpcionPerfil

        #region AdicionarFlujosEstadosPermisos
        /// <summary>
        /// 
        /// </summary>
        /// <param name="objDt"></param>
        /// <returns></returns>
        public bool AdicionarFlujosEstadosPermisos(FlujosEstadosPermisosData objDt)
        {
            bool blnFlujoEstadoPermiso = false;
            try
            {
                foreach (DataRow row in objDt.Rows)
                {
                    SqlParameter param1 = new SqlParameter(PER_ID_PARAM, row[FlujosEstadosPermisosData.PER_ID_FIELD]);
                    SqlParameter param2 = new SqlParameter(OPC_ID_PARAM, row[FlujosEstadosPermisosData.OPC_ID_FIELD]);
                    SqlParameter param3 = new SqlParameter(ACC_ID_PARAM, row[FlujosEstadosPermisosData.ACC_ID_FIELD]);
                    SqlParameter param4 = new SqlParameter(FLE_ESTADO_INICIAL_PARAM, row[FlujosEstadosPermisosData.FLE_ESTADO_INICIAL_FIELD]);
                    SqlParameter param5 = new SqlParameter(FLE_ESTADO_FINAL_PARAM, row[FlujosEstadosPermisosData.FLE_ESTADO_FINAL_FIELD]);
                    SqlParameter param6 = new SqlParameter(FLE_EXIGE_VIGENCIA_PARAM, row[FlujosEstadosPermisosData.FLE_EXIGE_VIGENCIA_FIELD]);
                    SqlParameter param7 = new SqlParameter(FLE_EXIGE_INFO_ADICIONAL_PARAM, row[FlujosEstadosPermisosData.FLE_EXIGE_INFO_ADICIONAL_FIELD]);
                    SqlParameter param8 = new SqlParameter(FEP_ID_PARAM, SqlDbType.Int);

                    param8.Direction = ParameterDirection.Output;

                    SqlParameter[] parameters = { param1, param2, param3, param4, param5, param6, param7, param8 };

                    SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.StoredProcedure, "PAS_ADICIONAR_ADM_FLUJO_ESTADO_PERMISO", parameters);
                }
                blnFlujoEstadoPermiso = true;
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_ADICIONAR_ADM_FLUJO_ESTADO_PERMISO"), sqlEx);
            }
            catch (Exception e)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorInsertar", "PAS_ADICIONAR_ADM_FLUJO_ESTADO_PERMISO"), e);
            }
            return blnFlujoEstadoPermiso;
        }
        #endregion AdicionarFlujosEstadosPermisos

        #region ActualizarFlujosEstadosPermisos
        /// <summary>
        /// 
        /// </summary>
        /// <param name="objDt"></param>
        public bool ActualizarFlujosEstadosPermisos(FlujosEstadosPermisosData objDt, params SqlTransaction[] objTransaccion)
        {
            bool respuesta = true;
            try
            {
                foreach (DataRow row in objDt.Rows)
                {
                    SqlParameter param1 = new SqlParameter(FEP_ID_PARAM, row[FlujosEstadosPermisosData.FEP_ID_FIELD]);
                    SqlParameter param2 = new SqlParameter(PER_ID_PARAM, row[FlujosEstadosPermisosData.PER_ID_FIELD]);
                    SqlParameter param3 = new SqlParameter(OPC_ID_PARAM, row[FlujosEstadosPermisosData.OPC_ID_FIELD]);
                    SqlParameter param4 = new SqlParameter(ACC_ID_PARAM, row[FlujosEstadosPermisosData.ACC_ID_FIELD]);
                    SqlParameter param5 = new SqlParameter(FLE_ESTADO_INICIAL_PARAM, row[FlujosEstadosPermisosData.FLE_ESTADO_INICIAL_FIELD]);
                    SqlParameter param6 = new SqlParameter(FLE_ESTADO_FINAL_PARAM, row[FlujosEstadosPermisosData.FLE_ESTADO_FINAL_FIELD]);
                    SqlParameter param7 = new SqlParameter(FLE_EXIGE_VIGENCIA_PARAM, row[FlujosEstadosPermisosData.FLE_EXIGE_VIGENCIA_FIELD]);
                    SqlParameter param8 = new SqlParameter(FLE_EXIGE_INFO_ADICIONAL_PARAM, row[FlujosEstadosPermisosData.FLE_EXIGE_INFO_ADICIONAL_FIELD]);

                    SqlParameter[] parameters = { param1, param2, param3, param4, param5, param6, param7, param8 };

                    if (objTransaccion.Length > 0)
                        SqlHelper.ExecuteNonQuery(objTransaccion[0], CommandType.StoredProcedure, "PAS_ACTUALIZAR_ADM_FLUJO_ESTADO_PERMISO", parameters);
                    else
                        SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.StoredProcedure, "PAS_ACTUALIZAR_ADM_FLUJO_ESTADO_PERMISO", parameters);
                }
            }
            catch (SqlException sqlEx)
            {
                respuesta = false;
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "Flujos Estados Permisos"), sqlEx);
            }
            catch (Exception e)
            {
                respuesta = false;
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorActualizar", "Flujos Estados Permisos"), e);
            }
            return respuesta;
        }
        #endregion ActualizarFlujosEstadosPermisos

        #region EliminarFlujosestadosPermisos
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ArrId"></param>
        public void EliminarFlujosestadosPermisos(ArrayList ArrId)
        {
            SqlConnection objConn = new SqlConnection(ConnectionString);
            objConn.Open();
            SqlTransaction objTrans = objConn.BeginTransaction();
            try
            {
                foreach (object Item in ArrId)
                {
                    SqlParameter param1 = new SqlParameter(FEP_ID_PARAM, Convert.ToInt32(Item));
                    SqlParameter[] parameters = { param1 };
                    SqlHelper.ExecuteNonQuery(objTrans, CommandType.StoredProcedure, "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO", parameters);
                }
                objTrans.Commit();
            }
            catch (SqlException sqlEx)
            {
                objTrans.Rollback();
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "Flujos Estados Permisos"), sqlEx);
            }
            catch (Exception e)
            {
                objTrans.Rollback();
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorEliminar", "Flujos Estados Permisos"), e);
            }
            finally
            {
                objConn.Close();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="intIdFlujoEstadoPermiso"></param>
        public void EliminarFlujosestadosPermisos(int intIdFlujoEstadoPermiso)
        {
            try
            {
                SqlParameter param1 = new SqlParameter(FEP_ID_PARAM, intIdFlujoEstadoPermiso);
                SqlParameter[] parameters = { param1 };
                SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.StoredProcedure, "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO", parameters);
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO"), sqlEx);
            }
            catch (Exception e)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorEliminar", "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO"), e);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="idperfil"></param>
        /// <param name="idopcion"></param>
        /// <param name="objTransaccion"></param>
        public bool EliminarFlujosestadosPermisos(decimal idperfil, decimal idopcion)
        {
            bool respuesta = true;
            try
            {
                SqlParameter param1 = new SqlParameter(PER_ID_PARAM, idperfil);
                SqlParameter param2 = new SqlParameter(OPC_ID_PARAM, idopcion);
                SqlParameter[] parameters = { param1, param2 };
                SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.StoredProcedure, "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO_POR_PERFIL_OPCION", parameters);
            }
            catch (SqlException sqlEx)
            {
                respuesta = false;
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "Flujos Estados Permisos"), sqlEx);
            }
            catch (Exception e)
            {
                respuesta = false;
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorEliminar", "Flujos Estados Permisos"), e);
            }
            return respuesta;
        }

        public bool EliminarFlujosestadosPermisos(FlujosEstadosPermisosData objDt)
        {
            bool response = false;
            try
            {
                foreach (DataRow row in objDt.Rows)
                {
                    SqlParameter param1 = new SqlParameter(FEP_ID_PARAM, row[FlujosEstadosPermisosData.FEP_ID_FIELD]);
                    SqlParameter[] parameters = { param1 };
                    SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.StoredProcedure, "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO", parameters);
                }
                response = true;
            }
            catch (SqlException sqlEx)
            {
                throw new ApplicationExceptionManager(Utilidad.DisplaySqlErrors(sqlEx, "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO"), sqlEx);
            }
            catch (Exception e)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgErrorEliminar", "PAS_ELIMINAR_ADM_FLUJO_ESTADO_PERMISO"), e);
            }
            return response;
        }
        #endregion EliminarFlujosestadosPermisos

        public bool EjecutarCambios(FlujosEstadosPermisosData datos, out string mensaje)
        {
            mensaje = String.Empty;
            bool response = false;
            bool responseAdd = false;
            bool responseDelete = false;
            bool responseUpdate = false;
            FlujosEstadosPermisosData dataAdicionar = new FlujosEstadosPermisosData();
            FlujosEstadosPermisosData dataEliminar = new FlujosEstadosPermisosData();
            FlujosEstadosPermisosData dataActualizar = new FlujosEstadosPermisosData();

            if (datos != null && datos.Rows.Count > 0)
            {
                foreach (DataRow row in datos.Rows)
                {
                    switch (row.RowState)
                    {
                        case DataRowState.Added:
                            dataAdicionar.ImportRow(row);
                            break;
                        case DataRowState.Modified:
                            dataActualizar.ImportRow(row);
                            break;
                        case DataRowState.Deleted:
                            DataRow dataRow = dataEliminar.NewRow();
                            dataRow[FlujosEstadosPermisosData.FEP_ID_FIELD] = row[FlujosEstadosPermisosData.FEP_ID_FIELD, DataRowVersion.Original];
                            dataEliminar.Add(dataRow);
                            break;
                    }
                }
            }

            try
            {
                if (dataAdicionar != null && dataAdicionar.Rows.Count > 0)
                {
                    responseAdd = AdicionarFlujosEstadosPermisos(dataAdicionar);
                }
                if (dataActualizar != null && dataActualizar.Rows.Count > 0)
                {
                    responseUpdate = ActualizarFlujosEstadosPermisos(dataActualizar);
                }
                if (dataEliminar != null && dataEliminar.Rows.Count > 0)
                {
                    responseDelete = EliminarFlujosestadosPermisos(dataEliminar);
                }
            }
            catch (Exception ex)
            {
                throw new ApplicationExceptionManager(Utilidad.TraerMensaje("gmsgCambiosNoExitoso", GetType().FullName), ex);
            }

            if (responseAdd || responseDelete || responseUpdate)
            {
                response = true;
            }
            mensaje = Mensaje;
            return response;
        }

        #endregion Publicos

        #region Privados
        #endregion privados

        #endregion Metodos
    }
}
